Git Kata 3: Merging

Merging is essentially the opposite of branching. Branches allow changes in a repository to be separated. Merging is the process of combining work that’s separated between branches.

Step 1: Merge changes between branches#

The command to merge changes is given below.

The output will be something like this:

The git merge command replays the changes from another branch on the current branch. Git will attempt to combine the commits from the source branch to the current branch. The result of the merge operation depends on the differences (if there are any) between the branches. The output of this command is:

The previous step made a modification to storelist.txt in newbranch. The git merge newbranch command instructs Git to take the changes from newbranch and apply them to the current branch.

Git has several methods, called merge strategies, it can use to determine how to merge changes. This execution of Git merge uses the fast-forward strategy.

The main branch had no commits on it since the newbranch commit was added. Git was able to merge them efficiently by simply moving the HEAD and main refs to point to the latest commit in the commit history. When Git executes a fast-forward merge, only the refs are updated, so no new commits are necessary. Git merged the changes by updating the HEAD and main refs to point to the commit in newbranch. The next step will demonstrate merging where different versions of the same file exist in both branches.

Switch back to the text editor and reload the file.

The merge operation has updated storelist.txt in the working directory, applying the changes made in newbranch to the current branch, main. The “First line last” commit from newbranch has been applied to the main branch.

Step 2: Merge branches with divergent histories#

To append the text in the file and save:

• Add (I love yogurt!) to the second line.
• Save the changes.

The next several steps will demonstrate merging two branches with differing versions of the same file. This step makes the first change to storelist.txt while main is the current branch.

The command to commit the change to the repository is given below.

When we execute the command above, the output will be something like this:

This step commits the change just made to storelist.txt in the main branch.

The command to witch to newbranch is given below.

The result will be something like this:

This step checks out newbranch.

To append the text in the file and save:

• Return to the text editor and reload the file.
• Add (lowfat please) to Moo Milk.
• Enter “Ctrl”+“S” to save.

This step makes a change on newbranch to a different line than the one changed in the main branch.

The command to commit the change to the repository is given below.

After the execution of the above command, the output will be something like this:

This step commits the change made to the Moo Milk line.

The output of this command is:

The updated visualization shows a truly divergent commit history. There are now two different versions of storelist.txt: one version in main and a different version in newbranch. The HEAD ref points to the commit in newbranch because it’s the most recent commit, and newbranch is the current branch.

The command to switch to main is given below.

The output of this command will be something like this:

This step uses git checkout to switch back to the main branch.

The command to display the differences between main and newbranch is given below:

After the execution of the above command, the output will be something like this:

The git diff command is used to compare two objects. This step uses git diff to view the differences between the main branch and newbranch. git diff can be used to view the differences in branches when preparing for a merge.

The text-based format of the git diff command shows differences between the two compared objects. When comparing two branches, as this execution does, all the differences are listed. If there were more than one file with differences in the repository, they would be included in the output.

The output of git diff is designed to be machine-readable so that it can be fed into other commands and programs. Graphical diff tools present a more readable visual difference report. It’s possible and useful to learn to read this format.

The output of the command is:

This output displays the differences in storelist.txt between the main and newbranch branches. With practice, we can learn to use this information to predict the results of a merge. Graphical tools are also available to display the differences visually, which makes that process easier.

The commands to merge the commits on newbranch to main are given below.

• Click “Ctrl”+“O.”
• Click “Enter.”
• Click “Ctrl”+“X.”
• View storelist.txt in the editor.
• Reload to see the changes.

The output will be something like this:

This step creates a merge using the same command as in the previous step. However, the results of this merge are quite different due to the fact that it’s not a fast-forward merge.

The commit histories of main and newbranch are different in this case, so Git cannot perform a fast-forward merge. Git must perform a three-way merge. A three-way merge takes two commits and combines them together in a third commit: a merge commit. Merge commits are different from the commits we’ve seen so far in that they have two (or more) parents instead of one.

The default merge strategy, in this case, is called recursive. This execution of the Git merge resulted in an auto-merge. The Git merge algorithm has some smarts built into it so that Git can merge automatically whenever possible.

The recursive merge strategy favors the current branch by default (known as the ours option). Git assumes that we want the current branch, main, to take priority when merging. The differences in storelist.txt are on different lines, so Git can infer the result of the merge. The next kata will demonstrate a case where Git can’t guess what we want, so the conflicts must be resolved by hand.

The output of this command is:

Note: We can refer to the output from the previous git diff command to track the changes that are applied by the merge:

-Moo Milk (lowfat please): This line is in the “from” version. It will be present in the merge result because there’s no conflicting change in the main branch version. This is the 1 insertion(+) from the output.

+Moo Milk: This line is in the “to” version in the main branch. This line hasn’t changed in the main branch since the change in newbranch, so Git applies the other version. This is the “1 deletion(-)” from the output.

Note: The latest commit is the merge commit created by the merge. Merge commits have at least two parents.

Practice commands#

We’ve given a terminal and a table containing a list of commands discussed in this lesson. Try out these commands after running the terminal and check out the results!